#ifndef GLOBALDEFINE_H
#define GLOBALDEFINE_H

#include <QString>
#include <QByteArray>
#include <QMetaType> // 必须包含
// 定义计时模式的枚举
enum class TimerMode {
    Countdown,  // 倒计时
    Stopwatch   // 正计时
};
// 声明为 Qt 元对象系统的可用类型
Q_DECLARE_METATYPE(TimerMode)

// 定义计时信息结构体
struct TimerConfig {
    bool isTimerEnabled;            // 是否开启计时
    TimerMode mode;                 // 计时模式：倒计时或正计时
    int durationMs;                 // 计时时长（单位：毫秒）
    int alarm1Ms;                   // 报警1的值（单位：毫秒）
    bool isAlarm1Enabled;
    int alarm2Ms;                   // 报警2的值（单位：毫秒）
    bool isAlarm2Enabled;
    int alarm3Ms;                   // 报警3的值（单位：毫秒）
    bool isAlarm3Enabled;
    int timeoutMs;                  // 超时的值（单位：毫秒）
    bool isTimeoutEnabled;
    bool isContinuousReminder;      // 是否持续提醒

    // 构造函数，初始化默认值
    TimerConfig(bool enabled = false,
                TimerMode mode = TimerMode::Stopwatch,
                int duration = 0,
                int alarm1 = 0,
                bool alarm1Enable = false,
                int alarm2 = 0,
                bool alarm2Enable = false,
                int alarm3 = 0,
                bool alarm3Enable = false,
                int timeout = 0,
                bool timeoutEnable = false,
                bool continuousReminder = false)
        : isTimerEnabled(enabled),
        mode(mode),
        durationMs(duration),
        alarm1Ms(alarm1),
        isAlarm1Enabled(alarm1Enable),
        alarm2Ms(alarm2),
        isAlarm2Enabled(alarm2Enable),
        alarm3Ms(alarm3),
        isAlarm3Enabled(alarm3Enable),
        timeoutMs(timeout),
        isTimeoutEnabled(timeoutEnable),
        isContinuousReminder(continuousReminder) {}
};

// 定义计时样式的枚举
enum class TimeFormat {
    Seconds             =   0x00000001,         // "sss"（秒）
    MinuteSecond        =   0x00000002,         // "mm:ss"（分：秒）
    HourMinuteSecond    =   0x00000004          // "hh:mm:ss"（小时：分：秒）
};
// 声明为 Qt 元对象系统的可用类型
Q_DECLARE_METATYPE(TimeFormat)
// 超时动作类型枚举
enum class TimeoutActionType {
    TimeoutCount,   // 超时计时
    StopCount,      // 停止计时
    LoopCount       // 循环计时
};
// 声明为 Qt 元对象系统的可用类型
Q_DECLARE_METATYPE(TimeoutActionType)
// 屏幕操作类型枚举
enum class ScreenAction {
    SemiTransparent, // 屏幕半透明
    BlackScreen,     // 屏幕黑屏
    WhiteScreen      // 屏幕白屏
};
// 声明为 Qt 元对象系统的可用类型
Q_DECLARE_METATYPE(ScreenAction)
// 记录超时动作信息的结构体
struct TimeoutAction {
    TimeoutActionType actionType;  // 超时动作类型
    ScreenAction screenAction;    // 屏幕状态

    // 构造函数，用于初始化结构体的值
    TimeoutAction(TimeoutActionType action = TimeoutActionType::TimeoutCount,
                  ScreenAction screen = ScreenAction::SemiTransparent)
        : actionType(action), screenAction(screen) {}

    // 输出超时动作和屏幕操作的字符串表示
    QString toString() const {
        QString actionStr;
        switch (actionType) {
        case TimeoutActionType::TimeoutCount: actionStr = "Timeout Count"; break;
        case TimeoutActionType::StopCount: actionStr = "Stop Count"; break;
        case TimeoutActionType::LoopCount: actionStr = "Loop Count"; break;
        }

        QString screenStr;
        switch (screenAction) {
        case ScreenAction::SemiTransparent: screenStr = "Semi Transparent"; break;
        case ScreenAction::BlackScreen: screenStr = "Black Screen"; break;
        case ScreenAction::WhiteScreen: screenStr = "White Screen"; break;
        }

        return QString("Action: %1, Screen: %2").arg(actionStr).arg(screenStr);
    }
};

// 播放设置结构体
struct PlaybackSettings {
    bool smartTiming;      // 智能计时（是否启用智能计时）
    bool timelySetting;    // 及时设置（是否启用及时设置）
    bool pauseTiming;      // 暂停计时（是否启用暂停计时）
    bool noSwitchTime;     // 不切换时间（是否启用不切换时间）
    bool hideWhenNotTiming;// 不计时隐藏（是否启用不计时隐藏）
    bool dualScreenDisplay;// 副屏显示（是否启用副屏显示）

    // 构造函数，用于初始化所有属性的值
    PlaybackSettings(bool smart = false, bool timely = false, bool pause = false,
                     bool noSwitch = false, bool hide = false, bool dualScreen = false)
        : smartTiming(smart), timelySetting(timely), pauseTiming(pause),
        noSwitchTime(noSwitch), hideWhenNotTiming(hide), dualScreenDisplay(dualScreen) {}

    // 输出播放设置的字符串表示
    QString toString() const {
        return QString("Smart Timing: %1, Timely Setting: %2, Pause Timing: %3, "
                       "No Switch Time: %4, Hide When Not Timing: %5, Dual Screen Display: %6")
            .arg(smartTiming ? "Enabled" : "Disabled")
            .arg(timelySetting ? "Enabled" : "Disabled")
            .arg(pauseTiming ? "Enabled" : "Disabled")
            .arg(noSwitchTime ? "Enabled" : "Disabled")
            .arg(hideWhenNotTiming ? "Enabled" : "Disabled")
            .arg(dualScreenDisplay ? "Enabled" : "Disabled");
    }
};

// 背景设置结构体
struct BackgroundSettings {
    bool isTransparent;    // 是否背景透明
    QString filePath;      // 背景文件路径
    int radius;            // 半径大小（例如：圆角背景的半径）

    // 构造函数，用于初始化所有属性的值
    BackgroundSettings(bool transparent = false, const QString& path = "", int r = 0)
        : isTransparent(transparent), filePath(path), radius(r) {}

    // 输出背景设置的字符串表示
    QString toString() const {
        return QString("Background Transparent: %1, File Path: %2, Radius: %3")
        .arg(isTransparent ? "Yes" : "No")
            .arg(filePath.isEmpty() ? "None" : filePath)
            .arg(radius);
    }
};

#include <QString>

// 单个声音信息结构体
struct SoundInfo {
    QString soundFilePath; // 声音文件路径
    bool isSoundEnabled;   // 是否打开声音
    bool isFlashing;       // 是否闪烁
    bool isTextVisible;    // 是否显示文字

    // 构造函数初始化所有成员
    SoundInfo(const QString& filePath = "", bool soundEnabled = true, bool flashing = false, bool textVisible = false)
        : soundFilePath(filePath), isSoundEnabled(soundEnabled), isFlashing(flashing), isTextVisible(textVisible) {}

    // 输出声音信息的字符串表示
    QString toString() const {
        return QString("Sound File: %1, Sound Enabled: %2, Flashing: %3, Text Visible: %4")
        .arg(soundFilePath.isEmpty() ? "None" : soundFilePath)
            .arg(isSoundEnabled ? "Yes" : "No")
            .arg(isFlashing ? "Yes" : "No")
            .arg(isTextVisible ? "Yes" : "No");
    }
};

enum class TipType
{
    START,
    ALARM1,
    ALARM2,
    ALARM3,
    TIMEOUT,
    END,
};
// 声明为 Qt 元对象系统的可用类型
Q_DECLARE_METATYPE(TipType)

// 存储所有声音设置的结构体
struct SoundSettings {
    SoundInfo start;   // 开始声音设置
    SoundInfo alarm1;  // 报警1声音设置
    SoundInfo alarm2;  // 报警2声音设置
    SoundInfo alarm3;  // 报警3声音设置
    SoundInfo timeout; // 超时声音设置
    SoundInfo end;     // 结束声音设置

    // 构造函数初始化所有声音设置
    SoundSettings(const SoundInfo& startInfo = SoundInfo(), const SoundInfo& alarm1Info = SoundInfo(),
                  const SoundInfo& alarm2Info = SoundInfo(), const SoundInfo& alarm3Info = SoundInfo(),
                  const SoundInfo& timeoutInfo = SoundInfo(), const SoundInfo& endInfo = SoundInfo())
        : start(startInfo), alarm1(alarm1Info), alarm2(alarm2Info), alarm3(alarm3Info), timeout(timeoutInfo), end(endInfo) {}

    // 输出所有声音设置的字符串表示
    QString toString() const {
        return QString("Start: [%1], Alarm1: [%2], Alarm2: [%3], Alarm3: [%4], Timeout: [%5], End: [%6]")
        .arg(start.toString())
            .arg(alarm1.toString())
            .arg(alarm2.toString())
            .arg(alarm3.toString())
            .arg(timeout.toString())
            .arg(end.toString());
    }
};
#endif // GLOBALDEFINE_H
